home *** CD-ROM | disk | FTP | other *** search
/ Champak 141 / (Vol 141) Oct 17 2011.iso / Games / Clueless.swf / scripts / org / flintparticles / emitters / Emitter.as
Encoding:
Text File  |  2011-10-17  |  15.5 KB  |  555 lines
  1. package org.flintparticles.emitters
  2. {
  3.    import flash.display.DisplayObject;
  4.    import flash.display.Shape;
  5.    import flash.events.Event;
  6.    import flash.events.EventDispatcher;
  7.    import flash.geom.Point;
  8.    import flash.utils.getTimer;
  9.    import org.flintparticles.actions.Action;
  10.    import org.flintparticles.activities.Activity;
  11.    import org.flintparticles.counters.Counter;
  12.    import org.flintparticles.counters.ZeroCounter;
  13.    import org.flintparticles.events.FlintEvent;
  14.    import org.flintparticles.initializers.Initializer;
  15.    import org.flintparticles.particles.Particle;
  16.    import org.flintparticles.particles.ParticleCreator;
  17.    import org.flintparticles.particles.ParticleFactory;
  18.    import org.flintparticles.renderers.Renderer;
  19.    import org.flintparticles.utils.DisplayObjectUtils;
  20.    import org.flintparticles.utils.Maths;
  21.    
  22.    public class Emitter extends EventDispatcher
  23.    {
  24.       
  25.       protected static var _creator:ParticleCreator = new ParticleCreator();
  26.        
  27.       
  28.       protected var _x:Number = 0;
  29.       
  30.       protected var _actionsPriority:Array;
  31.       
  32.       protected var _particlesPriority:Array;
  33.       
  34.       protected var _activities:Array;
  35.       
  36.       protected var _renderer:Renderer;
  37.       
  38.       private var _ticker:Shape;
  39.       
  40.       private var _time:int;
  41.       
  42.       protected var _particles:Array;
  43.       
  44.       protected var _initializers:Array;
  45.       
  46.       protected var _counter:Counter;
  47.       
  48.       protected var _actions:Array;
  49.       
  50.       public var spaceSort:Boolean = false;
  51.       
  52.       protected var _activitiesPriority:Array;
  53.       
  54.       public var spaceSortedX:Array;
  55.       
  56.       protected var _rotation:Number = 0;
  57.       
  58.       protected var _particleFactory:ParticleFactory;
  59.       
  60.       protected var _initializersPriority:Array;
  61.       
  62.       protected var _maximumFrameTime:Number = 0.5;
  63.       
  64.       protected var _y:Number = 0;
  65.       
  66.       public function Emitter()
  67.       {
  68.          _x = 0;
  69.          _y = 0;
  70.          _rotation = 0;
  71.          _maximumFrameTime = 0.5;
  72.          spaceSort = false;
  73.          super();
  74.          _particleFactory = _creator;
  75.          _particles = new Array();
  76.          _actions = new Array();
  77.          _initializers = new Array();
  78.          _activities = new Array();
  79.          _particlesPriority = new Array();
  80.          _actionsPriority = new Array();
  81.          _initializersPriority = new Array();
  82.          _activitiesPriority = new Array();
  83.          _counter = new ZeroCounter();
  84.          _ticker = new Shape();
  85.       }
  86.       
  87.       public function set rotation(param1:Number) : void
  88.       {
  89.          _rotation = Maths.asRadians(param1);
  90.       }
  91.       
  92.       public function addInitializer(param1:Initializer, param2:Number = NaN) : void
  93.       {
  94.          var _loc3_:int = 0;
  95.          if(isNaN(param2))
  96.          {
  97.             param2 = param1.getDefaultPriority();
  98.          }
  99.          _loc3_ = 0;
  100.          while(_loc3_ < _initializersPriority.length)
  101.          {
  102.             if(_initializersPriority[_loc3_] < param2)
  103.             {
  104.                break;
  105.             }
  106.             _loc3_++;
  107.          }
  108.          _initializers.splice(_loc3_,0,param1);
  109.          _initializersPriority.splice(_loc3_,0,param2);
  110.          param1.addedToEmitter(this);
  111.       }
  112.       
  113.       public function get y() : Number
  114.       {
  115.          return _y;
  116.       }
  117.       
  118.       public function set renderer(param1:Renderer) : void
  119.       {
  120.          _renderer = param1;
  121.       }
  122.       
  123.       public function rendererGlobalToLocal(param1:Point) : Point
  124.       {
  125.          var _loc2_:Point = null;
  126.          _loc2_ = param1.clone();
  127.          if(_renderer is DisplayObject)
  128.          {
  129.             _loc2_ = DisplayObject(_renderer).globalToLocal(_loc2_);
  130.          }
  131.          return _loc2_;
  132.       }
  133.       
  134.       public function get maximumFrameTime() : Number
  135.       {
  136.          return _maximumFrameTime;
  137.       }
  138.       
  139.       public function get rotRadians() : Number
  140.       {
  141.          return _rotation;
  142.       }
  143.       
  144.       protected function frameUpdate(param1:Number) : void
  145.       {
  146.          var _loc2_:int = 0;
  147.          var _loc3_:Particle = null;
  148.          var _loc4_:int = 0;
  149.          var _loc5_:Action = null;
  150.          var _loc6_:int = 0;
  151.          var _loc7_:int = 0;
  152.          _loc4_ = int(_counter.updateEmitter(this,param1));
  153.          _loc2_ = 0;
  154.          while(_loc2_ < _loc4_)
  155.          {
  156.             createParticle();
  157.             _loc2_++;
  158.          }
  159.          if(spaceSort)
  160.          {
  161.             spaceSortedX = _particles.sortOn("x",Array.NUMERIC | Array.RETURNINDEXEDARRAY);
  162.             _loc4_ = int(_particles.length);
  163.             _loc2_ = 0;
  164.             while(_loc2_ < _loc4_)
  165.             {
  166.                _particles[spaceSortedX[_loc2_]].spaceSortX = _loc2_;
  167.                _loc2_++;
  168.             }
  169.          }
  170.          _loc4_ = int(_activities.length);
  171.          _loc2_ = 0;
  172.          while(_loc2_ < _loc4_)
  173.          {
  174.             _activities[_loc2_].update(this,param1);
  175.             _loc2_++;
  176.          }
  177.          if(_particles.length > 0)
  178.          {
  179.             _loc4_ = int(_actions.length);
  180.             _loc6_ = int(_particles.length);
  181.             _loc7_ = 0;
  182.             while(_loc7_ < _loc4_)
  183.             {
  184.                _loc5_ = _actions[_loc7_];
  185.                _loc2_ = 0;
  186.                while(_loc2_ < _loc6_)
  187.                {
  188.                   _loc3_ = _particles[_loc2_];
  189.                   _loc5_.update(this,_loc3_,param1);
  190.                   _loc2_++;
  191.                }
  192.                _loc7_++;
  193.             }
  194.             _loc2_ = _loc6_;
  195.             while(_loc2_--)
  196.             {
  197.                _loc3_ = _particles[_loc2_];
  198.                if(_loc3_.isDead)
  199.                {
  200.                   destroyParticle(_loc3_);
  201.                   _particles.splice(_loc2_,1);
  202.                }
  203.             }
  204.          }
  205.          else
  206.          {
  207.             dispatchEvent(new FlintEvent(FlintEvent.EMITTER_EMPTY));
  208.          }
  209.          if(_renderer)
  210.          {
  211.             _renderer.renderParticles(_particles);
  212.          }
  213.       }
  214.       
  215.       public function get counter() : Counter
  216.       {
  217.          return _counter;
  218.       }
  219.       
  220.       public function set y(param1:Number) : void
  221.       {
  222.          _y = param1;
  223.       }
  224.       
  225.       public function get particleFactory() : ParticleFactory
  226.       {
  227.          return _particleFactory;
  228.       }
  229.       
  230.       public function dispose() : void
  231.       {
  232.          var _loc1_:int = 0;
  233.          var _loc2_:int = 0;
  234.          _ticker.removeEventListener(Event.ENTER_FRAME,frameLoop);
  235.          _loc1_ = int(_particles.length);
  236.          _loc2_ = 0;
  237.          while(_loc2_ < _loc1_)
  238.          {
  239.             destroyParticle(_particles[_loc2_]);
  240.             _loc2_++;
  241.          }
  242.          _particles.length = 0;
  243.       }
  244.       
  245.       private function destroyParticle(param1:Particle) : void
  246.       {
  247.          dispatchEvent(new FlintEvent(FlintEvent.PARTICLE_DEAD,param1));
  248.          if(_renderer)
  249.          {
  250.             _renderer.removeParticle(param1);
  251.          }
  252.          _particleFactory.disposeParticle(param1);
  253.       }
  254.       
  255.       public function rendererLocalToGlobal(param1:Point) : Point
  256.       {
  257.          var _loc2_:Point = null;
  258.          _loc2_ = param1.clone();
  259.          if(_renderer is DisplayObject)
  260.          {
  261.             _loc2_ = DisplayObject(_renderer).localToGlobal(_loc2_);
  262.          }
  263.          return _loc2_;
  264.       }
  265.       
  266.       public function get particles() : Array
  267.       {
  268.          return _particles;
  269.       }
  270.       
  271.       protected function createParticle() : Particle
  272.       {
  273.          var _loc1_:Particle = null;
  274.          var _loc2_:int = 0;
  275.          var _loc3_:int = 0;
  276.          _loc1_ = _particleFactory.createParticle();
  277.          _loc2_ = int(_initializers.length);
  278.          _loc1_.x = _x;
  279.          _loc1_.y = _y;
  280.          _loc1_.rotation = _rotation;
  281.          _loc3_ = 0;
  282.          while(_loc3_ < _loc2_)
  283.          {
  284.             _initializers[_loc3_].initialize(this,_loc1_);
  285.             _loc3_++;
  286.          }
  287.          _particles.push(_loc1_);
  288.          if(_renderer)
  289.          {
  290.             _renderer.addParticle(_loc1_);
  291.          }
  292.          dispatchEvent(new FlintEvent(FlintEvent.PARTICLE_CREATED,_loc1_));
  293.          return _loc1_;
  294.       }
  295.       
  296.       public function set maximumFrameTime(param1:Number) : void
  297.       {
  298.          _maximumFrameTime = param1;
  299.       }
  300.       
  301.       public function set rotRadians(param1:Number) : void
  302.       {
  303.          _rotation = param1;
  304.       }
  305.       
  306.       public function addAction(param1:Action, param2:Number = NaN) : void
  307.       {
  308.          var _loc3_:int = 0;
  309.          if(isNaN(param2))
  310.          {
  311.             param2 = param1.getDefaultPriority();
  312.          }
  313.          _loc3_ = 0;
  314.          while(_loc3_ < _actionsPriority.length)
  315.          {
  316.             if(_actionsPriority[_loc3_] < param2)
  317.             {
  318.                break;
  319.             }
  320.             _loc3_++;
  321.          }
  322.          _actions.splice(_loc3_,0,param1);
  323.          _actionsPriority.splice(_loc3_,0,param2);
  324.          param1.addedToEmitter(this);
  325.       }
  326.       
  327.       private function frameLoop(param1:Event) : void
  328.       {
  329.          var _loc2_:int = 0;
  330.          var _loc3_:Number = NaN;
  331.          _loc2_ = _time;
  332.          _time = getTimer();
  333.          _loc3_ = (_time - _loc2_) * 0.001;
  334.          if(_loc3_ <= _maximumFrameTime)
  335.          {
  336.             frameUpdate(_loc3_);
  337.          }
  338.       }
  339.       
  340.       private function addDisplayObject(param1:DisplayObject) : void
  341.       {
  342.          var _loc2_:Particle = null;
  343.          var _loc3_:int = 0;
  344.          var _loc4_:int = 0;
  345.          var _loc5_:DisplayObject = null;
  346.          var _loc6_:Point = null;
  347.          var _loc7_:Number = NaN;
  348.          _loc2_ = _particleFactory.createParticle();
  349.          _loc3_ = int(_initializers.length);
  350.          _loc4_ = 0;
  351.          while(_loc4_ < _loc3_)
  352.          {
  353.             _initializers[_loc4_].initialize(this,_loc2_);
  354.             _loc4_++;
  355.          }
  356.          _loc5_ = _renderer as DisplayObject;
  357.          if(Boolean(param1.parent) && Boolean(_loc5_))
  358.          {
  359.             _loc6_ = _loc5_.globalToLocal(param1.localToGlobal(new Point(0,0)));
  360.             _loc2_.x = _loc6_.x;
  361.             _loc2_.y = _loc6_.y;
  362.             _loc7_ = DisplayObjectUtils.globalToLocalRotation(_loc5_,DisplayObjectUtils.localToGlobalRotation(param1,0));
  363.             _loc2_.rotation = Maths.asRadians(_loc7_);
  364.             param1.parent.removeChild(param1);
  365.          }
  366.          else
  367.          {
  368.             _loc2_.x = param1.x;
  369.             _loc2_.y = param1.y;
  370.             _loc2_.rotation = Maths.asRadians(param1.rotation);
  371.          }
  372.          _loc2_.image = param1;
  373.          _particles.unshift(_loc2_);
  374.          _renderer.addParticle(_loc2_);
  375.       }
  376.       
  377.       public function resume() : void
  378.       {
  379.          _ticker.removeEventListener(Event.ENTER_FRAME,frameLoop);
  380.          _ticker.addEventListener(Event.ENTER_FRAME,frameLoop);
  381.          _time = getTimer();
  382.       }
  383.       
  384.       public function removeActivity(param1:Activity) : void
  385.       {
  386.          var _loc2_:int = 0;
  387.          _loc2_ = 0;
  388.          while(_loc2_ < _activities.length)
  389.          {
  390.             if(_activities[_loc2_] == param1)
  391.             {
  392.                _activities.splice(_loc2_,1);
  393.                _activitiesPriority.splice(_loc2_,1);
  394.                param1.removedFromEmitter(this);
  395.                return;
  396.             }
  397.             _loc2_++;
  398.          }
  399.       }
  400.       
  401.       public function get renderer() : Renderer
  402.       {
  403.          return _renderer;
  404.       }
  405.       
  406.       public function removeInitializer(param1:Initializer) : void
  407.       {
  408.          var _loc2_:int = 0;
  409.          _loc2_ = 0;
  410.          while(_loc2_ < _initializers.length)
  411.          {
  412.             if(_initializers[_loc2_] == param1)
  413.             {
  414.                _initializers.splice(_loc2_,1);
  415.                _initializersPriority.splice(_loc2_,1);
  416.                param1.removedFromEmitter(this);
  417.                return;
  418.             }
  419.             _loc2_++;
  420.          }
  421.       }
  422.       
  423.       public function set particleFactory(param1:ParticleFactory) : void
  424.       {
  425.          _particleFactory = param1;
  426.       }
  427.       
  428.       public function addActivity(param1:Activity, param2:Number = NaN) : void
  429.       {
  430.          var _loc3_:int = 0;
  431.          if(isNaN(param2))
  432.          {
  433.             param2 = param1.getDefaultPriority();
  434.          }
  435.          _loc3_ = 0;
  436.          while(_loc3_ < _activitiesPriority.length)
  437.          {
  438.             if(_activitiesPriority[_loc3_] < param2)
  439.             {
  440.                break;
  441.             }
  442.             _loc3_++;
  443.          }
  444.          _activities.splice(_loc3_,0,param1);
  445.          _activitiesPriority.splice(_loc3_,0,param2);
  446.          param1.addedToEmitter(this);
  447.       }
  448.       
  449.       public function removeAction(param1:Action) : void
  450.       {
  451.          var _loc2_:int = 0;
  452.          _loc2_ = 0;
  453.          while(_loc2_ < _actions.length)
  454.          {
  455.             if(_actions[_loc2_] == param1)
  456.             {
  457.                _actions.splice(_loc2_,1);
  458.                _actionsPriority.splice(_loc2_,1);
  459.                param1.removedFromEmitter(this);
  460.                return;
  461.             }
  462.             _loc2_++;
  463.          }
  464.       }
  465.       
  466.       public function start() : void
  467.       {
  468.          var _loc1_:int = 0;
  469.          var _loc2_:int = 0;
  470.          _ticker.removeEventListener(Event.ENTER_FRAME,frameLoop);
  471.          _ticker.addEventListener(Event.ENTER_FRAME,frameLoop);
  472.          _time = getTimer();
  473.          _loc1_ = int(_activities.length);
  474.          _loc2_ = 0;
  475.          while(_loc2_ < _loc1_)
  476.          {
  477.             _activities[_loc2_].initialize(this);
  478.             _loc2_++;
  479.          }
  480.          _loc1_ = int(_counter.startEmitter(this));
  481.          _loc2_ = 0;
  482.          while(_loc2_ < _loc1_)
  483.          {
  484.             createParticle();
  485.             _loc2_++;
  486.          }
  487.       }
  488.       
  489.       public function set x(param1:Number) : void
  490.       {
  491.          _x = param1;
  492.       }
  493.       
  494.       public function addDisplayObjects(... rest) : void
  495.       {
  496.          var _loc2_:Number = NaN;
  497.          var _loc3_:Number = NaN;
  498.          _loc2_ = 0;
  499.          while(_loc2_ < rest.length)
  500.          {
  501.             if(rest[_loc2_] is Array)
  502.             {
  503.                _loc3_ = 0;
  504.                while(_loc3_ < rest[_loc2_].length)
  505.                {
  506.                   if(rest[_loc2_][_loc3_] is DisplayObject)
  507.                   {
  508.                      addDisplayObject(rest[_loc2_][_loc3_]);
  509.                   }
  510.                   _loc3_++;
  511.                }
  512.             }
  513.             else if(rest[_loc2_] is DisplayObject)
  514.             {
  515.                addDisplayObject(rest[_loc2_]);
  516.             }
  517.             _loc2_++;
  518.          }
  519.       }
  520.       
  521.       public function pause() : void
  522.       {
  523.          _ticker.removeEventListener(Event.ENTER_FRAME,frameLoop);
  524.       }
  525.       
  526.       public function get x() : Number
  527.       {
  528.          return _x;
  529.       }
  530.       
  531.       public function runAhead(param1:Number, param2:Number = 10) : void
  532.       {
  533.          var _loc3_:Number = NaN;
  534.          pause();
  535.          _loc3_ = 1 / param2;
  536.          while(param1 > 0)
  537.          {
  538.             param1 -= _loc3_;
  539.             frameUpdate(_loc3_);
  540.          }
  541.          resume();
  542.       }
  543.       
  544.       public function get rotation() : Number
  545.       {
  546.          return Maths.asDegrees(_rotation);
  547.       }
  548.       
  549.       public function set counter(param1:Counter) : void
  550.       {
  551.          _counter = param1;
  552.       }
  553.    }
  554. }
  555.